home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / idlelib / PyParse.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  9.4 KB  |  419 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import re
  5. import sys
  6. (C_NONE, C_BACKSLASH, C_STRING, C_BRACKET) = range(4)
  7. _synchre = re.compile('\n    ^\n    [ \\t]*\n    (?: if\n    |   for\n    |   while\n    |   else\n    |   def\n    |   return\n    |   assert\n    |   break\n    |   class\n    |   continue\n    |   elif\n    |   try\n    |   except\n    |   raise\n    |   import\n    |   yield\n    )\n    \\b\n', re.VERBOSE | re.MULTILINE).search
  8. _junkre = re.compile('\n    [ \\t]*\n    (?: \\# \\S .* )?\n    \\n\n', re.VERBOSE).match
  9. _match_stringre = re.compile('\n    \\""" [^"\\\\]* (?:\n                     (?: \\\\. | "(?!"") )\n                     [^"\\\\]*\n                 )*\n    (?: \\""" )?\n\n|   " [^"\\\\\\n]* (?: \\\\. [^"\\\\\\n]* )* "?\n\n|   \'\'\' [^\'\\\\]* (?:\n                   (?: \\\\. | \'(?!\'\') )\n                   [^\'\\\\]*\n                )*\n    (?: \'\'\' )?\n\n|   \' [^\'\\\\\\n]* (?: \\\\. [^\'\\\\\\n]* )* \'?\n', re.VERBOSE | re.DOTALL).match
  10. _itemre = re.compile('\n    [ \\t]*\n    [^\\s#\\\\]    # if we match, m.end()-1 is the interesting char\n', re.VERBOSE).match
  11. _closere = re.compile('\n    \\s*\n    (?: return\n    |   break\n    |   continue\n    |   raise\n    |   pass\n    )\n    \\b\n', re.VERBOSE).match
  12. _chew_ordinaryre = re.compile('\n    [^[\\](){}#\'"\\\\]+\n', re.VERBOSE).match
  13. _tran = [
  14.     'x'] * 256
  15. for ch in '({[':
  16.     _tran[ord(ch)] = '('
  17.  
  18. for ch in ')}]':
  19.     _tran[ord(ch)] = ')'
  20.  
  21. for ch in '"\'\\\n#':
  22.     _tran[ord(ch)] = ch
  23.  
  24. _tran = ''.join(_tran)
  25. del ch
  26.  
  27. try:
  28.     UnicodeType = type(unicode(''))
  29. except NameError:
  30.     UnicodeType = None
  31.  
  32.  
  33. class Parser:
  34.     
  35.     def __init__(self, indentwidth, tabwidth):
  36.         self.indentwidth = indentwidth
  37.         self.tabwidth = tabwidth
  38.  
  39.     
  40.     def set_str(self, str):
  41.         if not len(str) == 0 and str[-1] == '\n':
  42.             raise AssertionError
  43.         if type(str) is UnicodeType:
  44.             uniphooey = str
  45.             str = []
  46.             push = str.append
  47.             for raw in map(ord, uniphooey):
  48.                 if not raw < 127 or chr(raw):
  49.                     pass
  50.                 push('x')
  51.             
  52.             str = ''.join(str)
  53.         
  54.         self.str = str
  55.         self.study_level = 0
  56.  
  57.     
  58.     def find_good_parse_start(self, use_ps1, is_char_in_string = None, _synchre = _synchre):
  59.         str = self.str
  60.         pos = None
  61.         if use_ps1:
  62.             ps1 = '\n' + sys.ps1
  63.             i = str.rfind(ps1)
  64.             if i >= 0:
  65.                 pos = i + len(ps1)
  66.                 self.str = str[:pos - 1] + '\n' + str[pos:]
  67.             
  68.             return pos
  69.         
  70.         if not is_char_in_string:
  71.             return None
  72.         
  73.         limit = len(str)
  74.         for tries in range(5):
  75.             i = str.rfind(':\n', 0, limit)
  76.             if i < 0:
  77.                 break
  78.             
  79.             i = str.rfind('\n', 0, i) + 1
  80.             m = _synchre(str, i, limit)
  81.             if m and not is_char_in_string(m.start()):
  82.                 pos = m.start()
  83.                 break
  84.             
  85.             limit = i
  86.         
  87.         if pos is None:
  88.             m = _synchre(str)
  89.             if m and not is_char_in_string(m.start()):
  90.                 pos = m.start()
  91.             
  92.             return pos
  93.         
  94.         i = pos + 1
  95.         while None:
  96.             m = _synchre(str, i)
  97.             if m:
  98.                 (s, i) = m.span()
  99.                 if not is_char_in_string(s):
  100.                     pos = s
  101.                 
  102.             break
  103.         return pos
  104.  
  105.     
  106.     def set_lo(self, lo):
  107.         if not lo == 0 and self.str[lo - 1] == '\n':
  108.             raise AssertionError
  109.         if lo > 0:
  110.             self.str = self.str[lo:]
  111.         
  112.  
  113.     
  114.     def _study1(self):
  115.         if self.study_level >= 1:
  116.             return None
  117.         
  118.         self.study_level = 1
  119.         str = self.str
  120.         str = str.translate(_tran)
  121.         str = str.replace('xxxxxxxx', 'x')
  122.         str = str.replace('xxxx', 'x')
  123.         str = str.replace('xx', 'x')
  124.         str = str.replace('xx', 'x')
  125.         str = str.replace('\nx', '\n')
  126.         continuation = C_NONE
  127.         level = lno = 0
  128.         self.goodlines = goodlines = [
  129.             0]
  130.         push_good = goodlines.append
  131.         i = 0
  132.         n = len(str)
  133.         while i < n:
  134.             ch = str[i]
  135.             i = i + 1
  136.             if ch == 'x':
  137.                 continue
  138.             
  139.             if ch == '\n':
  140.                 lno = lno + 1
  141.                 if level == 0:
  142.                     push_good(lno)
  143.                     continue
  144.                 continue
  145.             
  146.             if ch == '(':
  147.                 level = level + 1
  148.                 continue
  149.             
  150.             if ch == ')':
  151.                 if level:
  152.                     level = level - 1
  153.                     continue
  154.                 continue
  155.             
  156.             if ch == '"' or ch == "'":
  157.                 quote = ch
  158.                 if str[i - 1:i + 2] == quote * 3:
  159.                     quote = quote * 3
  160.                 
  161.                 w = len(quote) - 1
  162.                 i = i + w
  163.                 while i < n:
  164.                     ch = str[i]
  165.                     i = i + 1
  166.                     if ch == 'x':
  167.                         continue
  168.                     
  169.                     if str[i - 1:i + w] == quote:
  170.                         i = i + w
  171.                         break
  172.                     
  173.                     if ch == '\n':
  174.                         lno = lno + 1
  175.                         if w == 0:
  176.                             if level == 0:
  177.                                 push_good(lno)
  178.                             
  179.                             break
  180.                             continue
  181.                         continue
  182.                     
  183.                     if ch == '\\':
  184.                         if not i < n:
  185.                             raise AssertionError
  186.                         if str[i] == '\n':
  187.                             lno = lno + 1
  188.                         
  189.                         i = i + 1
  190.                         continue
  191.                         continue
  192.                 continuation = C_STRING
  193.                 continue
  194.             
  195.             if ch == '#':
  196.                 i = str.find('\n', i)
  197.                 if not i >= 0:
  198.                     raise AssertionError
  199.                 continue
  200.             
  201.             if not ch == '\\':
  202.                 raise AssertionError
  203.             if not i < n:
  204.                 raise AssertionError
  205.             if str[i] == '\n':
  206.                 lno = lno + 1
  207.                 if i + 1 == n:
  208.                     continuation = C_BACKSLASH
  209.                 
  210.             
  211.             i = i + 1
  212.         if continuation != C_STRING and level > 0:
  213.             continuation = C_BRACKET
  214.         
  215.         self.continuation = continuation
  216.         if not continuation == C_NONE == goodlines[-1] == lno:
  217.             raise AssertionError
  218.         if goodlines[-1] != lno:
  219.             push_good(lno)
  220.         
  221.  
  222.     
  223.     def get_continuation_type(self):
  224.         self._study1()
  225.         return self.continuation
  226.  
  227.     
  228.     def _study2(self):
  229.         if self.study_level >= 2:
  230.             return None
  231.         
  232.         self._study1()
  233.         self.study_level = 2
  234.         str = self.str
  235.         goodlines = self.goodlines
  236.         i = len(goodlines) - 1
  237.         p = len(str)
  238.         while i:
  239.             if not p:
  240.                 raise AssertionError
  241.             q = p
  242.             for nothing in range(goodlines[i - 1], goodlines[i]):
  243.                 p = str.rfind('\n', 0, p - 1) + 1
  244.             
  245.             if _junkre(str, p):
  246.                 i = i - 1
  247.                 continue
  248.             break
  249.         if i == 0:
  250.             if not p == 0:
  251.                 raise AssertionError
  252.             q = p
  253.         
  254.         self.stmt_start = p
  255.         self.stmt_end = q
  256.         lastch = ''
  257.         stack = []
  258.         push_stack = stack.append
  259.         while p < q:
  260.             m = _chew_ordinaryre(str, p, q)
  261.             if m:
  262.                 newp = m.end()
  263.                 i = newp - 1
  264.                 while i >= p and str[i] in ' \t\n':
  265.                     i = i - 1
  266.                 if i >= p:
  267.                     lastch = str[i]
  268.                 
  269.                 p = newp
  270.                 if p >= q:
  271.                     break
  272.                 
  273.             
  274.             ch = str[p]
  275.             if ch in '([{':
  276.                 push_stack(p)
  277.                 lastch = ch
  278.                 p = p + 1
  279.                 continue
  280.             
  281.             if ch in ')]}':
  282.                 if stack:
  283.                     del stack[-1]
  284.                 
  285.                 lastch = ch
  286.                 p = p + 1
  287.                 continue
  288.             
  289.             if ch == '"' or ch == "'":
  290.                 lastch = ch
  291.                 p = _match_stringre(str, p, q).end()
  292.                 continue
  293.             
  294.             if ch == '#':
  295.                 p = str.find('\n', p, q) + 1
  296.                 if not p > 0:
  297.                     raise AssertionError
  298.                 continue
  299.             
  300.             if not ch == '\\':
  301.                 raise AssertionError
  302.             p = p + 1
  303.             if not p < q:
  304.                 raise AssertionError
  305.             if str[p] != '\n':
  306.                 lastch = ch + str[p]
  307.             
  308.             p = p + 1
  309.         self.lastch = lastch
  310.         if stack:
  311.             self.lastopenbracketpos = stack[-1]
  312.         
  313.  
  314.     
  315.     def compute_bracket_indent(self):
  316.         self._study2()
  317.         if not self.continuation == C_BRACKET:
  318.             raise AssertionError
  319.         j = self.lastopenbracketpos
  320.         str = self.str
  321.         n = len(str)
  322.         origi = i = str.rfind('\n', 0, j) + 1
  323.         j = j + 1
  324.         while j < n:
  325.             m = _itemre(str, j)
  326.             if m:
  327.                 j = m.end() - 1
  328.                 extra = 0
  329.                 break
  330.                 continue
  331.             i = j = str.find('\n', j) + 1
  332.         j = i = origi
  333.         while str[j] in ' \t':
  334.             j = j + 1
  335.         extra = self.indentwidth
  336.         return len(str[i:j].expandtabs(self.tabwidth)) + extra
  337.  
  338.     
  339.     def get_num_lines_in_stmt(self):
  340.         self._study1()
  341.         goodlines = self.goodlines
  342.         return goodlines[-1] - goodlines[-2]
  343.  
  344.     
  345.     def compute_backslash_indent(self):
  346.         self._study2()
  347.         if not self.continuation == C_BACKSLASH:
  348.             raise AssertionError
  349.         str = self.str
  350.         i = self.stmt_start
  351.         while str[i] in ' \t':
  352.             i = i + 1
  353.         startpos = i
  354.         endpos = str.find('\n', startpos) + 1
  355.         found = level = 0
  356.         while i < endpos:
  357.             ch = str[i]
  358.             if ch in '([{':
  359.                 level = level + 1
  360.                 i = i + 1
  361.                 continue
  362.             if ch in ')]}':
  363.                 if level:
  364.                     level = level - 1
  365.                 
  366.                 i = i + 1
  367.                 continue
  368.             if ch == '"' or ch == "'":
  369.                 i = _match_stringre(str, i, endpos).end()
  370.                 continue
  371.             if ch == '#':
  372.                 break
  373.                 continue
  374.             if level == 0 and ch == '=':
  375.                 if (i == 0 or str[i - 1] not in '=<>!') and str[i + 1] != '=':
  376.                     found = 1
  377.                     break
  378.                     continue
  379.             i = i + 1
  380.         if found:
  381.             i = i + 1
  382.             found = re.match('\\s*\\\\', str[i:endpos]) is None
  383.         
  384.         if not found:
  385.             i = startpos
  386.             while str[i] not in ' \t\n':
  387.                 i = i + 1
  388.         
  389.         return len(str[self.stmt_start:i].expandtabs(self.tabwidth)) + 1
  390.  
  391.     
  392.     def get_base_indent_string(self):
  393.         self._study2()
  394.         i = self.stmt_start
  395.         n = self.stmt_end
  396.         j = i
  397.         str = self.str
  398.         while j < n and str[j] in ' \t':
  399.             j = j + 1
  400.         return str[i:j]
  401.  
  402.     
  403.     def is_block_opener(self):
  404.         self._study2()
  405.         return self.lastch == ':'
  406.  
  407.     
  408.     def is_block_closer(self):
  409.         self._study2()
  410.         return _closere(self.str, self.stmt_start) is not None
  411.  
  412.     lastopenbracketpos = None
  413.     
  414.     def get_last_open_bracket_pos(self):
  415.         self._study2()
  416.         return self.lastopenbracketpos
  417.  
  418.  
  419.